home *** CD-ROM | disk | FTP | other *** search
- # Source Generated with Decompyle++
- # File: in.pyc (Python 2.4)
-
- '''
- This is a Py2.3 implementation of decimal floating point arithmetic based on
- the General Decimal Arithmetic Specification:
-
- www2.hursley.ibm.com/decimal/decarith.html
-
- and IEEE standard 854-1987:
-
- www.cs.berkeley.edu/~ejr/projects/754/private/drafts/854-1987/dir.html
-
- Decimal floating point has finite precision with arbitrarily large bounds.
-
- The purpose of the module is to support arithmetic using familiar
- "schoolhouse" rules and to avoid the some of tricky representation
- issues associated with binary floating point. The package is especially
- useful for financial applications or for contexts where users have
- expectations that are at odds with binary floating point (for instance,
- in binary floating point, 1.00 % 0.1 gives 0.09999999999999995 instead
- of the expected Decimal("0.00") returned by decimal floating point).
-
- Here are some examples of using the decimal module:
-
- >>> from decimal import *
- >>> setcontext(ExtendedContext)
- >>> Decimal(0)
- Decimal("0")
- >>> Decimal("1")
- Decimal("1")
- >>> Decimal("-.0123")
- Decimal("-0.0123")
- >>> Decimal(123456)
- Decimal("123456")
- >>> Decimal("123.45e12345678901234567890")
- Decimal("1.2345E+12345678901234567892")
- >>> Decimal("1.33") + Decimal("1.27")
- Decimal("2.60")
- >>> Decimal("12.34") + Decimal("3.87") - Decimal("18.41")
- Decimal("-2.20")
- >>> dig = Decimal(1)
- >>> print dig / Decimal(3)
- 0.333333333
- >>> getcontext().prec = 18
- >>> print dig / Decimal(3)
- 0.333333333333333333
- >>> print dig.sqrt()
- 1
- >>> print Decimal(3).sqrt()
- 1.73205080756887729
- >>> print Decimal(3) ** 123
- 4.85192780976896427E+58
- >>> inf = Decimal(1) / Decimal(0)
- >>> print inf
- Infinity
- >>> neginf = Decimal(-1) / Decimal(0)
- >>> print neginf
- -Infinity
- >>> print neginf + inf
- NaN
- >>> print neginf * inf
- -Infinity
- >>> print dig / 0
- Infinity
- >>> getcontext().traps[DivisionByZero] = 1
- >>> print dig / 0
- Traceback (most recent call last):
- ...
- ...
- ...
- DivisionByZero: x / 0
- >>> c = Context()
- >>> c.traps[InvalidOperation] = 0
- >>> print c.flags[InvalidOperation]
- 0
- >>> c.divide(Decimal(0), Decimal(0))
- Decimal("NaN")
- >>> c.traps[InvalidOperation] = 1
- >>> print c.flags[InvalidOperation]
- 1
- >>> c.flags[InvalidOperation] = 0
- >>> print c.flags[InvalidOperation]
- 0
- >>> print c.divide(Decimal(0), Decimal(0))
- Traceback (most recent call last):
- ...
- ...
- ...
- InvalidOperation: 0 / 0
- >>> print c.flags[InvalidOperation]
- 1
- >>> c.flags[InvalidOperation] = 0
- >>> c.traps[InvalidOperation] = 0
- >>> print c.divide(Decimal(0), Decimal(0))
- NaN
- >>> print c.flags[InvalidOperation]
- 1
- >>>
- '''
- __all__ = [
- 'Decimal',
- 'Context',
- 'DefaultContext',
- 'BasicContext',
- 'ExtendedContext',
- 'DecimalException',
- 'Clamped',
- 'InvalidOperation',
- 'DivisionByZero',
- 'Inexact',
- 'Rounded',
- 'Subnormal',
- 'Overflow',
- 'Underflow',
- 'ROUND_DOWN',
- 'ROUND_HALF_UP',
- 'ROUND_HALF_EVEN',
- 'ROUND_CEILING',
- 'ROUND_FLOOR',
- 'ROUND_UP',
- 'ROUND_HALF_DOWN',
- 'setcontext',
- 'getcontext']
- import copy as _copy
- ROUND_DOWN = 'ROUND_DOWN'
- ROUND_HALF_UP = 'ROUND_HALF_UP'
- ROUND_HALF_EVEN = 'ROUND_HALF_EVEN'
- ROUND_CEILING = 'ROUND_CEILING'
- ROUND_FLOOR = 'ROUND_FLOOR'
- ROUND_UP = 'ROUND_UP'
- ROUND_HALF_DOWN = 'ROUND_HALF_DOWN'
- NEVER_ROUND = 'NEVER_ROUND'
- ALWAYS_ROUND = 'ALWAYS_ROUND'
-
- class DecimalException(ArithmeticError):
- """Base exception class.
-
- Used exceptions derive from this.
- If an exception derives from another exception besides this (such as
- Underflow (Inexact, Rounded, Subnormal) that indicates that it is only
- called if the others are present. This isn't actually used for
- anything, though.
-
- handle -- Called when context._raise_error is called and the
- trap_enabler is set. First argument is self, second is the
- context. More arguments can be given, those being after
- the explanation in _raise_error (For example,
- context._raise_error(NewError, '(-x)!', self._sign) would
- call NewError().handle(context, self._sign).)
-
- To define a new exception, it should be sufficient to have it derive
- from DecimalException.
- """
-
- def handle(self, context, *args):
- pass
-
-
-
- class Clamped(DecimalException):
- '''Exponent of a 0 changed to fit bounds.
-
- This occurs and signals clamped if the exponent of a result has been
- altered in order to fit the constraints of a specific concrete
- representation. This may occur when the exponent of a zero result would
- be outside the bounds of a representation, or when a large normal
- number would have an encoded exponent that cannot be represented. In
- this latter case, the exponent is reduced to fit and the corresponding
- number of zero digits are appended to the coefficient ("fold-down").
- '''
- pass
-
-
- class InvalidOperation(DecimalException):
- '''An invalid operation was performed.
-
- Various bad things cause this:
-
- Something creates a signaling NaN
- -INF + INF
- 0 * (+-)INF
- (+-)INF / (+-)INF
- x % 0
- (+-)INF % x
- x._rescale( non-integer )
- sqrt(-x) , x > 0
- 0 ** 0
- x ** (non-integer)
- x ** (+-)INF
- An operand is invalid
- '''
-
- def handle(self, context, *args):
- if args:
- if args[0] == 1:
- return Decimal((args[1]._sign, args[1]._int, 'n'))
-
-
- return NaN
-
-
-
- class ConversionSyntax(InvalidOperation):
- '''Trying to convert badly formed string.
-
- This occurs and signals invalid-operation if an string is being
- converted to a number and it does not conform to the numeric string
- syntax. The result is [0,qNaN].
- '''
-
- def handle(self, context, *args):
- return (0, (0,), 'n')
-
-
-
- class DivisionByZero(DecimalException, ZeroDivisionError):
- '''Division by 0.
-
- This occurs and signals division-by-zero if division of a finite number
- by zero was attempted (during a divide-integer or divide operation, or a
- power operation with negative right-hand operand), and the dividend was
- not zero.
-
- The result of the operation is [sign,inf], where sign is the exclusive
- or of the signs of the operands for divide, or is 1 for an odd power of
- -0, for power.
- '''
-
- def handle(self, context, sign, double = None, *args):
- if double is not None:
- return (Infsign[sign],) * 2
-
- return Infsign[sign]
-
-
-
- class DivisionImpossible(InvalidOperation):
- '''Cannot perform the division adequately.
-
- This occurs and signals invalid-operation if the integer result of a
- divide-integer or remainder operation had too many digits (would be
- longer than precision). The result is [0,qNaN].
- '''
-
- def handle(self, context, *args):
- return (NaN, NaN)
-
-
-
- class DivisionUndefined(InvalidOperation, ZeroDivisionError):
- '''Undefined result of division.
-
- This occurs and signals invalid-operation if division by zero was
- attempted (during a divide-integer, divide, or remainder operation), and
- the dividend is also zero. The result is [0,qNaN].
- '''
-
- def handle(self, context, tup = None, *args):
- if tup is not None:
- return (NaN, NaN)
-
- return NaN
-
-
-
- class Inexact(DecimalException):
- '''Had to round, losing information.
-
- This occurs and signals inexact whenever the result of an operation is
- not exact (that is, it needed to be rounded and any discarded digits
- were non-zero), or if an overflow or underflow condition occurs. The
- result in all cases is unchanged.
-
- The inexact signal may be tested (or trapped) to determine if a given
- operation (or sequence of operations) was inexact.
- '''
- pass
-
-
- class InvalidContext(InvalidOperation):
- '''Invalid context. Unknown rounding, for example.
-
- This occurs and signals invalid-operation if an invalid context was
- detected during an operation. This can occur if contexts are not checked
- on creation and either the precision exceeds the capability of the
- underlying concrete representation or an unknown or unsupported rounding
- was specified. These aspects of the context need only be checked when
- the values are required to be used. The result is [0,qNaN].
- '''
-
- def handle(self, context, *args):
- return NaN
-
-
-
- class Rounded(DecimalException):
- '''Number got rounded (not necessarily changed during rounding).
-
- This occurs and signals rounded whenever the result of an operation is
- rounded (that is, some zero or non-zero digits were discarded from the
- coefficient), or if an overflow or underflow condition occurs. The
- result in all cases is unchanged.
-
- The rounded signal may be tested (or trapped) to determine if a given
- operation (or sequence of operations) caused a loss of precision.
- '''
- pass
-
-
- class Subnormal(DecimalException):
- '''Exponent < Emin before rounding.
-
- This occurs and signals subnormal whenever the result of a conversion or
- operation is subnormal (that is, its adjusted exponent is less than
- Emin, before any rounding). The result in all cases is unchanged.
-
- The subnormal signal may be tested (or trapped) to determine if a given
- or operation (or sequence of operations) yielded a subnormal result.
- '''
- pass
-
-
- class Overflow(Inexact, Rounded):
- '''Numerical overflow.
-
- This occurs and signals overflow if the adjusted exponent of a result
- (from a conversion or from an operation that is not an attempt to divide
- by zero), after rounding, would be greater than the largest value that
- can be handled by the implementation (the value Emax).
-
- The result depends on the rounding mode:
-
- For round-half-up and round-half-even (and for round-half-down and
- round-up, if implemented), the result of the operation is [sign,inf],
- where sign is the sign of the intermediate result. For round-down, the
- result is the largest finite number that can be represented in the
- current precision, with the sign of the intermediate result. For
- round-ceiling, the result is the same as for round-down if the sign of
- the intermediate result is 1, or is [0,inf] otherwise. For round-floor,
- the result is the same as for round-down if the sign of the intermediate
- result is 0, or is [1,inf] otherwise. In all cases, Inexact and Rounded
- will also be raised.
- '''
-
- def handle(self, context, sign, *args):
- if context.rounding in (ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_HALF_DOWN, ROUND_UP):
- return Infsign[sign]
-
- if sign == 0:
- if context.rounding == ROUND_CEILING:
- return Infsign[sign]
-
- return Decimal((sign, (9,) * context.prec, (context.Emax - context.prec) + 1))
-
- if sign == 1:
- if context.rounding == ROUND_FLOOR:
- return Infsign[sign]
-
- return Decimal((sign, (9,) * context.prec, (context.Emax - context.prec) + 1))
-
-
-
-
- class Underflow(Inexact, Rounded, Subnormal):
- '''Numerical underflow with result rounded to 0.
-
- This occurs and signals underflow if a result is inexact and the
- adjusted exponent of the result would be smaller (more negative) than
- the smallest value that can be handled by the implementation (the value
- Emin). That is, the result is both inexact and subnormal.
-
- The result after an underflow will be a subnormal number rounded, if
- necessary, so that its exponent is not less than Etiny. This may result
- in 0 with the sign of the intermediate result and an exponent of Etiny.
-
- In all cases, Inexact, Rounded, and Subnormal will also be raised.
- '''
- pass
-
- _signals = [
- Clamped,
- DivisionByZero,
- Inexact,
- Overflow,
- Rounded,
- Underflow,
- InvalidOperation,
- Subnormal]
- _condition_map = {
- ConversionSyntax: InvalidOperation,
- DivisionImpossible: InvalidOperation,
- DivisionUndefined: InvalidOperation,
- InvalidContext: InvalidOperation }
-
- try:
- import threading
- except ImportError:
- import sys
-
- class MockThreading:
-
- def local(self, sys = sys):
- return sys.modules[__name__]
-
-
- threading = MockThreading()
- del sys
- del MockThreading
-
-
- try:
- threading.local
- except AttributeError:
- if hasattr(threading.currentThread(), '__decimal_context__'):
- del threading.currentThread().__decimal_context__
-
-
- def setcontext(context):
- """Set this thread's context to context."""
- if context in (DefaultContext, BasicContext, ExtendedContext):
- context = context.copy()
- context.clear_flags()
-
- threading.currentThread().__decimal_context__ = context
-
-
- def getcontext():
- """Returns this thread's context.
-
- If this thread does not yet have a context, returns
- a new context and sets this thread's context.
- New contexts are copies of DefaultContext.
- """
-
- try:
- return threading.currentThread().__decimal_context__
- except AttributeError:
- context = Context()
- threading.currentThread().__decimal_context__ = context
- return context
-
-
-
- local = threading.local()
- if hasattr(local, '__decimal_context__'):
- del local.__decimal_context__
-
-
- def getcontext(_local = local):
- """Returns this thread's context.
-
- If this thread does not yet have a context, returns
- a new context and sets this thread's context.
- New contexts are copies of DefaultContext.
- """
-
- try:
- return _local.__decimal_context__
- except AttributeError:
- context = Context()
- _local.__decimal_context__ = context
- return context
-
-
-
- def setcontext(context, _local = local):
- """Set this thread's context to context."""
- if context in (DefaultContext, BasicContext, ExtendedContext):
- context = context.copy()
- context.clear_flags()
-
- _local.__decimal_context__ = context
-
- del threading
- del local
-
- class Decimal(object):
- '''Floating point class for decimal arithmetic.'''
- __slots__ = ('_exp', '_int', '_sign', '_is_special')
-
- def __new__(cls, value = '0', context = None):
- '''Create a decimal point instance.
-
- >>> Decimal(\'3.14\') # string input
- Decimal("3.14")
- >>> Decimal((0, (3, 1, 4), -2)) # tuple input (sign, digit_tuple, exponent)
- Decimal("3.14")
- >>> Decimal(314) # int or long
- Decimal("314")
- >>> Decimal(Decimal(314)) # another decimal instance
- Decimal("314")
- '''
- self = object.__new__(cls)
- self._is_special = False
- if isinstance(value, _WorkRep):
- self._sign = value.sign
- self._int = tuple(map(int, str(value.int)))
- self._exp = int(value.exp)
- return self
-
- if isinstance(value, Decimal):
- self._exp = value._exp
- self._sign = value._sign
- self._int = value._int
- self._is_special = value._is_special
- return self
-
- if isinstance(value, (int, long)):
- if value >= 0:
- self._sign = 0
- else:
- self._sign = 1
- self._exp = 0
- self._int = tuple(map(int, str(abs(value))))
- return self
-
- if isinstance(value, (list, tuple)):
- if len(value) != 3:
- raise ValueError, 'Invalid arguments'
-
- if value[0] not in (0, 1):
- raise ValueError, 'Invalid sign'
-
- for digit in value[1]:
- if not isinstance(digit, (int, long)) or digit < 0:
- raise ValueError, 'The second value in the tuple must be composed of non negative integer elements.'
- continue
-
- self._sign = value[0]
- self._int = tuple(value[1])
- if value[2] in ('F', 'n', 'N'):
- self._exp = value[2]
- self._is_special = True
- else:
- self._exp = int(value[2])
- return self
-
- if isinstance(value, float):
- raise TypeError('Cannot convert float to Decimal. ' + 'First convert the float to a string')
-
- if context is None:
- context = getcontext()
-
- if isinstance(value, basestring):
- if _isinfinity(value):
- self._exp = 'F'
- self._int = (0,)
- self._is_special = True
- if _isinfinity(value) == 1:
- self._sign = 0
- else:
- self._sign = 1
- return self
-
- if _isnan(value):
- (sig, sign, diag) = _isnan(value)
- self._is_special = True
- if len(diag) > context.prec:
- (self._sign, self._int, self._exp) = context._raise_error(ConversionSyntax)
- return self
-
- if sig == 1:
- self._exp = 'n'
- else:
- self._exp = 'N'
- self._sign = sign
- self._int = tuple(map(int, diag))
- return self
-
-
- try:
- (self._sign, self._int, self._exp) = _string2exact(value)
- except ValueError:
- self._is_special = True
- (self._sign, self._int, self._exp) = context._raise_error(ConversionSyntax)
-
- return self
-
- raise TypeError('Cannot convert %r to Decimal' % value)
-
-
- def _isnan(self):
- '''Returns whether the number is not actually one.
-
- 0 if a number
- 1 if NaN
- 2 if sNaN
- '''
- if self._is_special:
- exp = self._exp
- if exp == 'n':
- return 1
- elif exp == 'N':
- return 2
-
-
- return 0
-
-
- def _isinfinity(self):
- '''Returns whether the number is infinite
-
- 0 if finite or not a number
- 1 if +INF
- -1 if -INF
- '''
- if self._exp == 'F':
- if self._sign:
- return -1
-
- return 1
-
- return 0
-
-
- def _check_nans(self, other = None, context = None):
- '''Returns whether the number is not actually one.
-
- if self, other are sNaN, signal
- if self, other are NaN return nan
- return 0
-
- Done before operations.
- '''
- self_is_nan = self._isnan()
- if other is None:
- other_is_nan = False
- else:
- other_is_nan = other._isnan()
- if self_is_nan or other_is_nan:
- if context is None:
- context = getcontext()
-
- if self_is_nan == 2:
- return context._raise_error(InvalidOperation, 'sNaN', 1, self)
-
- if other_is_nan == 2:
- return context._raise_error(InvalidOperation, 'sNaN', 1, other)
-
- if self_is_nan:
- return self
-
- return other
-
- return 0
-
-
- def __nonzero__(self):
- '''Is the number non-zero?
-
- 0 if self == 0
- 1 if self != 0
- '''
- if self._is_special:
- return 1
-
- return sum(self._int) != 0
-
-
- def __cmp__(self, other, context = None):
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- if self._is_special or other._is_special:
- ans = self._check_nans(other, context)
- if ans:
- return 1
-
- return cmp(self._isinfinity(), other._isinfinity())
-
- if not self and not other:
- return 0
-
- if other._sign < self._sign:
- return -1
-
- if self._sign < other._sign:
- return 1
-
- self_adjusted = self.adjusted()
- other_adjusted = other.adjusted()
- if self_adjusted == other_adjusted and self._int + (0,) * (self._exp - other._exp) == other._int + (0,) * (other._exp - self._exp):
- return 0
- elif self_adjusted > other_adjusted and self._int[0] != 0:
- return -1 ** self._sign
- elif self_adjusted < other_adjusted and other._int[0] != 0:
- return --1 ** self._sign
-
- if context is None:
- context = getcontext()
-
- context = context._shallow_copy()
- rounding = context._set_rounding(ROUND_UP)
- flags = context._ignore_all_flags()
- res = self.__sub__(other, context = context)
- context._regard_flags(*flags)
- context.rounding = rounding
- if not res:
- return 0
- elif res._sign:
- return -1
-
- return 1
-
-
- def __eq__(self, other):
- if not isinstance(other, (Decimal, int, long)):
- return NotImplemented
-
- return self.__cmp__(other) == 0
-
-
- def __ne__(self, other):
- if not isinstance(other, (Decimal, int, long)):
- return NotImplemented
-
- return self.__cmp__(other) != 0
-
-
- def compare(self, other, context = None):
- '''Compares one to another.
-
- -1 => a < b
- 0 => a = b
- 1 => a > b
- NaN => one is NaN
- Like __cmp__, but returns Decimal instances.
- '''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- if (self._is_special or other) and other._is_special:
- ans = self._check_nans(other, context)
- if ans:
- return ans
-
-
- return Decimal(self.__cmp__(other, context))
-
-
- def __hash__(self):
- '''x.__hash__() <==> hash(x)'''
- if self._is_special:
- if self._isnan():
- raise TypeError('Cannot hash a NaN value.')
-
- return hash(str(self))
-
- i = int(self)
- if self == Decimal(i):
- return hash(i)
-
- if not self.__nonzero__():
- raise AssertionError
- return hash(str(self.normalize()))
-
-
- def as_tuple(self):
- '''Represents the number as a triple tuple.
-
- To show the internals exactly as they are.
- '''
- return (self._sign, self._int, self._exp)
-
-
- def __repr__(self):
- '''Represents the number as an instance of Decimal.'''
- return 'Decimal("%s")' % str(self)
-
-
- def __str__(self, eng = 0, context = None):
- '''Return string representation of the number in scientific notation.
-
- Captures all of the information in the underlying representation.
- '''
- if self._is_special:
- if self._isnan():
- minus = '-' * self._sign
- if self._int == (0,):
- info = ''
- else:
- info = ''.join(map(str, self._int))
- if self._isnan() == 2:
- return minus + 'sNaN' + info
-
- return minus + 'NaN' + info
-
- if self._isinfinity():
- minus = '-' * self._sign
- return minus + 'Infinity'
-
-
- if context is None:
- context = getcontext()
-
- tmp = map(str, self._int)
- numdigits = len(self._int)
- leftdigits = self._exp + numdigits
- if eng and not self:
- if self._exp < 0 and self._exp >= -6:
- s = '-' * self._sign + '0.' + '0' * abs(self._exp)
- return s
-
- exp = ((self._exp - 1) // 3 + 1) * 3
- if exp != self._exp:
- s = '0.' + '0' * (exp - self._exp)
- else:
- s = '0'
- if exp != 0:
- if context.capitals:
- s += 'E'
- else:
- s += 'e'
- if exp > 0:
- s += '+'
-
- s += str(exp)
-
- s = '-' * self._sign + s
- return s
-
- if eng:
- dotplace = (leftdigits - 1) % 3 + 1
- adjexp = leftdigits - 1 - (leftdigits - 1) % 3
- else:
- adjexp = leftdigits - 1
- dotplace = 1
- if self._exp == 0:
- pass
- elif self._exp < 0 and adjexp >= 0:
- tmp.insert(leftdigits, '.')
- elif self._exp < 0 and adjexp >= -6:
- tmp[0:0] = [
- '0'] * int(-leftdigits)
- tmp.insert(0, '0.')
- elif numdigits > dotplace:
- tmp.insert(dotplace, '.')
- elif numdigits < dotplace:
- tmp.extend([
- '0'] * (dotplace - numdigits))
-
- if adjexp:
- if not context.capitals:
- tmp.append('e')
- else:
- tmp.append('E')
- if adjexp > 0:
- tmp.append('+')
-
- tmp.append(str(adjexp))
-
- if eng:
- while tmp[0:1] == [
- '0']:
- tmp[0:1] = []
- if len(tmp) == 0 and tmp[0] == '.' or tmp[0].lower() == 'e':
- tmp[0:0] = [
- '0']
-
-
- if self._sign:
- tmp.insert(0, '-')
-
- return ''.join(tmp)
-
-
- def to_eng_string(self, context = None):
- '''Convert to engineering-type string.
-
- Engineering notation has an exponent which is a multiple of 3, so there
- are up to 3 digits left of the decimal place.
-
- Same rules for when in exponential and when as a value as in __str__.
- '''
- return self.__str__(eng = 1, context = context)
-
-
- def __neg__(self, context = None):
- '''Returns a copy with the sign switched.
-
- Rounds, if it has reason.
- '''
- if self._is_special:
- ans = self._check_nans(context = context)
- if ans:
- return ans
-
-
- if not self:
- sign = 0
- elif self._sign:
- sign = 0
- else:
- sign = 1
- if context is None:
- context = getcontext()
-
- if context._rounding_decision == ALWAYS_ROUND:
- return Decimal((sign, self._int, self._exp))._fix(context)
-
- return Decimal((sign, self._int, self._exp))
-
-
- def __pos__(self, context = None):
- '''Returns a copy, unless it is a sNaN.
-
- Rounds the number (if more then precision digits)
- '''
- if self._is_special:
- ans = self._check_nans(context = context)
- if ans:
- return ans
-
-
- sign = self._sign
- if not self:
- sign = 0
-
- if context is None:
- context = getcontext()
-
- if context._rounding_decision == ALWAYS_ROUND:
- ans = self._fix(context)
- else:
- ans = Decimal(self)
- ans._sign = sign
- return ans
-
-
- def __abs__(self, round = 1, context = None):
- '''Returns the absolute value of self.
-
- If the second argument is 0, do not round.
- '''
- if self._is_special:
- ans = self._check_nans(context = context)
- if ans:
- return ans
-
-
- if not round:
- if context is None:
- context = getcontext()
-
- context = context._shallow_copy()
- context._set_rounding_decision(NEVER_ROUND)
-
- if self._sign:
- ans = self.__neg__(context = context)
- else:
- ans = self.__pos__(context = context)
- return ans
-
-
- def __add__(self, other, context = None):
- '''Returns self + other.
-
- -INF + INF (or the reverse) cause InvalidOperation errors.
- '''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- if context is None:
- context = getcontext()
-
- if self._is_special or other._is_special:
- ans = self._check_nans(other, context)
- if ans:
- return ans
-
- if self._isinfinity():
- if self._sign != other._sign and other._isinfinity():
- return context._raise_error(InvalidOperation, '-INF + INF')
-
- return Decimal(self)
-
- if other._isinfinity():
- return Decimal(other)
-
-
- shouldround = context._rounding_decision == ALWAYS_ROUND
- exp = min(self._exp, other._exp)
- negativezero = 0
- if context.rounding == ROUND_FLOOR and self._sign != other._sign:
- negativezero = 1
-
- if not self and not other:
- sign = min(self._sign, other._sign)
- if negativezero:
- sign = 1
-
- return Decimal((sign, (0,), exp))
-
- if not self:
- exp = max(exp, other._exp - context.prec - 1)
- ans = other._rescale(exp, watchexp = 0, context = context)
- if shouldround:
- ans = ans._fix(context)
-
- return ans
-
- if not other:
- exp = max(exp, self._exp - context.prec - 1)
- ans = self._rescale(exp, watchexp = 0, context = context)
- if shouldround:
- ans = ans._fix(context)
-
- return ans
-
- op1 = _WorkRep(self)
- op2 = _WorkRep(other)
- (op1, op2) = _normalize(op1, op2, shouldround, context.prec)
- result = _WorkRep()
- if op1.sign != op2.sign:
- if op1.int == op2.int:
- if exp < context.Etiny():
- exp = context.Etiny()
- context._raise_error(Clamped)
-
- return Decimal((negativezero, (0,), exp))
-
- if op1.int < op2.int:
- op1 = op2
- op2 = op1
-
- if op1.sign == 1:
- result.sign = 1
- op1.sign = op2.sign
- op2.sign = op1.sign
- else:
- result.sign = 0
- elif op1.sign == 1:
- result.sign = 1
- (op1.sign, op2.sign) = (0, 0)
- else:
- result.sign = 0
- if op2.sign == 0:
- result.int = op1.int + op2.int
- else:
- result.int = op1.int - op2.int
- result.exp = op1.exp
- ans = Decimal(result)
- if shouldround:
- ans = ans._fix(context)
-
- return ans
-
- __radd__ = __add__
-
- def __sub__(self, other, context = None):
- '''Return self + (-other)'''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- if self._is_special or other._is_special:
- ans = self._check_nans(other, context = context)
- if ans:
- return ans
-
-
- tmp = Decimal(other)
- tmp._sign = 1 - tmp._sign
- return self.__add__(tmp, context = context)
-
-
- def __rsub__(self, other, context = None):
- '''Return other + (-self)'''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- tmp = Decimal(self)
- tmp._sign = 1 - tmp._sign
- return other.__add__(tmp, context = context)
-
-
- def _increment(self, round = 1, context = None):
- """Special case of add, adding 1eExponent
-
- Since it is common, (rounding, for example) this adds
- (sign)*one E self._exp to the number more efficiently than add.
-
- For example:
- Decimal('5.624e10')._increment() == Decimal('5.625e10')
- """
- if self._is_special:
- ans = self._check_nans(context = context)
- if ans:
- return ans
-
- return Decimal(self)
-
- L = list(self._int)
- L[-1] += 1
- spot = len(L) - 1
- while L[spot] == 10:
- L[spot] = 0
- if spot == 0:
- L[0:0] = [
- 1]
- break
-
- L[spot - 1] += 1
- spot -= 1
- ans = Decimal((self._sign, L, self._exp))
- if context is None:
- context = getcontext()
-
- if round and context._rounding_decision == ALWAYS_ROUND:
- ans = ans._fix(context)
-
- return ans
-
-
- def __mul__(self, other, context = None):
- '''Return self * other.
-
- (+-) INF * 0 (or its reverse) raise InvalidOperation.
- '''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- if context is None:
- context = getcontext()
-
- resultsign = self._sign ^ other._sign
- if self._is_special or other._is_special:
- ans = self._check_nans(other, context)
- if ans:
- return ans
-
- if self._isinfinity():
- if not other:
- return context._raise_error(InvalidOperation, '(+-)INF * 0')
-
- return Infsign[resultsign]
-
- if other._isinfinity():
- if not self:
- return context._raise_error(InvalidOperation, '0 * (+-)INF')
-
- return Infsign[resultsign]
-
-
- resultexp = self._exp + other._exp
- shouldround = context._rounding_decision == ALWAYS_ROUND
- if not self or not other:
- ans = Decimal((resultsign, (0,), resultexp))
- if shouldround:
- ans = ans._fix(context)
-
- return ans
-
- if self._int == (1,):
- ans = Decimal((resultsign, other._int, resultexp))
- if shouldround:
- ans = ans._fix(context)
-
- return ans
-
- if other._int == (1,):
- ans = Decimal((resultsign, self._int, resultexp))
- if shouldround:
- ans = ans._fix(context)
-
- return ans
-
- op1 = _WorkRep(self)
- op2 = _WorkRep(other)
- ans = Decimal((resultsign, map(int, str(op1.int * op2.int)), resultexp))
- if shouldround:
- ans = ans._fix(context)
-
- return ans
-
- __rmul__ = __mul__
-
- def __div__(self, other, context = None):
- '''Return self / other.'''
- return self._divide(other, context = context)
-
- __truediv__ = __div__
-
- def _divide(self, other, divmod = 0, context = None):
- '''Return a / b, to context.prec precision.
-
- divmod:
- 0 => true division
- 1 => (a //b, a%b)
- 2 => a //b
- 3 => a%b
-
- Actually, if divmod is 2 or 3 a tuple is returned, but errors for
- computing the other value are not raised.
- '''
- other = _convert_other(other)
- if other is NotImplemented:
- if divmod in (0, 1):
- return NotImplemented
-
- return (NotImplemented, NotImplemented)
-
- if context is None:
- context = getcontext()
-
- sign = self._sign ^ other._sign
- if self._is_special or other._is_special:
- ans = self._check_nans(other, context)
- if ans:
- if divmod:
- return (ans, ans)
-
- return ans
-
- if self._isinfinity() and other._isinfinity():
- if divmod:
- return (context._raise_error(InvalidOperation, '(+-)INF // (+-)INF'), context._raise_error(InvalidOperation, '(+-)INF % (+-)INF'))
-
- return context._raise_error(InvalidOperation, '(+-)INF/(+-)INF')
-
- if self._isinfinity():
- if divmod == 1:
- return (Infsign[sign], context._raise_error(InvalidOperation, 'INF % x'))
- elif divmod == 2:
- return (Infsign[sign], NaN)
- elif divmod == 3:
- return (Infsign[sign], context._raise_error(InvalidOperation, 'INF % x'))
-
- return Infsign[sign]
-
- if other._isinfinity():
- if divmod:
- return (Decimal((sign, (0,), 0)), Decimal(self))
-
- context._raise_error(Clamped, 'Division by infinity')
- return Decimal((sign, (0,), context.Etiny()))
-
-
- if not self and not other:
- if divmod:
- return context._raise_error(DivisionUndefined, '0 / 0', 1)
-
- return context._raise_error(DivisionUndefined, '0 / 0')
-
- if not self:
- if divmod:
- otherside = Decimal(self)
- otherside._exp = min(self._exp, other._exp)
- return (Decimal((sign, (0,), 0)), otherside)
-
- exp = self._exp - other._exp
- if exp < context.Etiny():
- exp = context.Etiny()
- context._raise_error(Clamped, '0e-x / y')
-
- if exp > context.Emax:
- exp = context.Emax
- context._raise_error(Clamped, '0e+x / y')
-
- return Decimal((sign, (0,), exp))
-
- if not other:
- if divmod:
- return context._raise_error(DivisionByZero, 'divmod(x,0)', sign, 1)
-
- return context._raise_error(DivisionByZero, 'x / 0', sign)
-
- shouldround = context._rounding_decision == ALWAYS_ROUND
- if divmod and self.__abs__(0, context) < other.__abs__(0, context):
- if divmod == 1 or divmod == 3:
- exp = min(self._exp, other._exp)
- ans2 = self._rescale(exp, context = context, watchexp = 0)
- if shouldround:
- ans2 = ans2._fix(context)
-
- return (Decimal((sign, (0,), 0)), ans2)
- elif divmod == 2:
- return (Decimal((sign, (0,), 0)), Decimal(self))
-
-
- op1 = _WorkRep(self)
- op2 = _WorkRep(other)
- (op1, op2, adjust) = _adjust_coefficients(op1, op2)
- res = _WorkRep((sign, 0, op1.exp - op2.exp))
- if divmod and res.exp > context.prec + 1:
- return context._raise_error(DivisionImpossible)
-
- prec_limit = 10 ** context.prec
- while None:
- while op2.int <= op1.int:
- res.int += 1
- op1.int -= op2.int
- continue
- op1
- if op1.int == 0 and adjust >= 0 and not divmod:
- break
-
- if res.int >= prec_limit and shouldround:
- if divmod:
- return context._raise_error(DivisionImpossible)
-
- shouldround = 1
- break
-
- res.int *= 10
- res.exp -= 1
- adjust += 1
- op1.int *= 10
- op1.exp -= 1
- if res.exp == 0 and divmod and op2.int > op1.int:
- otherside = Decimal(op1)
- frozen = context._ignore_all_flags()
- exp = min(self._exp, other._exp)
- otherside = otherside._rescale(exp, context = context)
- context._regard_flags(*frozen)
- return (Decimal(res), otherside)
- continue
- continue
- res
- ans = Decimal(res)
- if shouldround:
- ans = ans._fix(context)
-
- return ans
-
-
- def __rdiv__(self, other, context = None):
- '''Swaps self/other and returns __div__.'''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- return other.__div__(self, context = context)
-
- __rtruediv__ = __rdiv__
-
- def __divmod__(self, other, context = None):
- '''
- (self // other, self % other)
- '''
- return self._divide(other, 1, context)
-
-
- def __rdivmod__(self, other, context = None):
- '''Swaps self/other and returns __divmod__.'''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- return other.__divmod__(self, context = context)
-
-
- def __mod__(self, other, context = None):
- '''
- self % other
- '''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- if self._is_special or other._is_special:
- ans = self._check_nans(other, context)
- if ans:
- return ans
-
-
- if self and not other:
- return context._raise_error(InvalidOperation, 'x % 0')
-
- return self._divide(other, 3, context)[1]
-
-
- def __rmod__(self, other, context = None):
- '''Swaps self/other and returns __mod__.'''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- return other.__mod__(self, context = context)
-
-
- def remainder_near(self, other, context = None):
- '''
- Remainder nearest to 0- abs(remainder-near) <= other/2
- '''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- if self._is_special or other._is_special:
- ans = self._check_nans(other, context)
- if ans:
- return ans
-
-
- if self and not other:
- return context._raise_error(InvalidOperation, 'x % 0')
-
- if context is None:
- context = getcontext()
-
- context = context._shallow_copy()
- flags = context._ignore_flags(Rounded, Inexact)
- (side, r) = self.__divmod__(other, context = context)
- if r._isnan():
- context._regard_flags(*flags)
- return r
-
- context = context._shallow_copy()
- rounding = context._set_rounding_decision(NEVER_ROUND)
- if other._sign:
- comparison = other.__div__(Decimal(-2), context = context)
- else:
- comparison = other.__div__(Decimal(2), context = context)
- context._set_rounding_decision(rounding)
- context._regard_flags(*flags)
- s1 = r._sign
- s2 = comparison._sign
- (r._sign, comparison._sign) = (0, 0)
- if r < comparison:
- r._sign = s1
- comparison._sign = s2
- self.__divmod__(other, context = context)
- return r._fix(context)
-
- r._sign = s1
- comparison._sign = s2
- rounding = context._set_rounding_decision(NEVER_ROUND)
- (side, r) = self.__divmod__(other, context = context)
- context._set_rounding_decision(rounding)
- if r._isnan():
- return r
-
- decrease = not side._iseven()
- rounding = context._set_rounding_decision(NEVER_ROUND)
- side = side.__abs__(context = context)
- context._set_rounding_decision(rounding)
- s1 = r._sign
- s2 = comparison._sign
- (r._sign, comparison._sign) = (0, 0)
- return r._fix(context)
-
-
- def __floordiv__(self, other, context = None):
- '''self // other'''
- return self._divide(other, 2, context)[0]
-
-
- def __rfloordiv__(self, other, context = None):
- '''Swaps self/other and returns __floordiv__.'''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- return other.__floordiv__(self, context = context)
-
-
- def __float__(self):
- '''Float representation.'''
- return float(str(self))
-
-
- def __int__(self):
- '''Converts self to an int, truncating if necessary.'''
- if self._is_special:
- if self._isnan():
- context = getcontext()
- return context._raise_error(InvalidContext)
- elif self._isinfinity():
- raise OverflowError, 'Cannot convert infinity to long'
-
-
- if self._exp >= 0:
- s = ''.join(map(str, self._int)) + '0' * self._exp
- else:
- s = ''.join(map(str, self._int))[:self._exp]
- if s == '':
- s = '0'
-
- sign = '-' * self._sign
- return int(sign + s)
-
-
- def __long__(self):
- '''Converts to a long.
-
- Equivalent to long(int(self))
- '''
- return long(self.__int__())
-
-
- def _fix(self, context):
- '''Round if it is necessary to keep self within prec precision.
-
- Rounds and fixes the exponent. Does not raise on a sNaN.
-
- Arguments:
- self - Decimal instance
- context - context used.
- '''
- if self._is_special:
- return self
-
- if context is None:
- context = getcontext()
-
- prec = context.prec
- ans = self._fixexponents(context)
- if len(ans._int) > prec:
- ans = ans._round(prec, context = context)
- ans = ans._fixexponents(context)
-
- return ans
-
-
- def _fixexponents(self, context):
- '''Fix the exponents and return a copy with the exponent in bounds.
- Only call if known to not be a special value.
- '''
- folddown = context._clamp
- Emin = context.Emin
- ans = self
- ans_adjusted = ans.adjusted()
- if ans_adjusted < Emin:
- Etiny = context.Etiny()
- if ans._exp < Etiny:
- if not ans:
- ans = Decimal(self)
- ans._exp = Etiny
- context._raise_error(Clamped)
- return ans
-
- ans = ans._rescale(Etiny, context = context)
- context._raise_error(Subnormal)
- if context.flags[Inexact]:
- context._raise_error(Underflow)
-
- elif ans:
- context._raise_error(Subnormal)
-
- else:
- Etop = context.Etop()
- if folddown and ans._exp > Etop:
- context._raise_error(Clamped)
- ans = ans._rescale(Etop, context = context)
- else:
- Emax = context.Emax
- if ans_adjusted > Emax:
- if not ans:
- ans = Decimal(self)
- ans._exp = Emax
- context._raise_error(Clamped)
- return ans
-
- context._raise_error(Inexact)
- context._raise_error(Rounded)
- return context._raise_error(Overflow, 'above Emax', ans._sign)
-
- return ans
-
-
- def _round(self, prec = None, rounding = None, context = None):
- '''Returns a rounded version of self.
-
- You can specify the precision or rounding method. Otherwise, the
- context determines it.
- '''
- if self._is_special:
- ans = self._check_nans(context = context)
- if ans:
- return ans
-
- if self._isinfinity():
- return Decimal(self)
-
-
- if context is None:
- context = getcontext()
-
- if rounding is None:
- rounding = context.rounding
-
- if prec is None:
- prec = context.prec
-
- if not self:
- if prec <= 0:
- dig = (0,)
- exp = (len(self._int) - prec) + self._exp
- else:
- dig = (0,) * prec
- exp = len(self._int) + self._exp - prec
- ans = Decimal((self._sign, dig, exp))
- context._raise_error(Rounded)
- return ans
-
- if prec == 0:
- temp = Decimal(self)
- temp._int = (0,) + temp._int
- prec = 1
- elif prec < 0:
- exp = self._exp + len(self._int) - prec - 1
- temp = Decimal((self._sign, (0, 1), exp))
- prec = 1
- else:
- temp = Decimal(self)
- numdigits = len(temp._int)
- if prec == numdigits:
- return temp
-
- expdiff = prec - numdigits
- if expdiff > 0:
- tmp = list(temp._int)
- tmp.extend([
- 0] * expdiff)
- ans = Decimal((temp._sign, tmp, temp._exp - expdiff))
- return ans
-
- lostdigits = self._int[expdiff:]
- if lostdigits == (0,) * len(lostdigits):
- ans = Decimal((temp._sign, temp._int[:prec], temp._exp - expdiff))
- context._raise_error(Rounded)
- return ans
-
- this_function = getattr(temp, self._pick_rounding_function[rounding])
- if prec != context.prec:
- context = context._shallow_copy()
- context.prec = prec
-
- ans = this_function(prec, expdiff, context)
- context._raise_error(Rounded)
- context._raise_error(Inexact, 'Changed in rounding')
- return ans
-
- _pick_rounding_function = { }
-
- def _round_down(self, prec, expdiff, context):
- '''Also known as round-towards-0, truncate.'''
- return Decimal((self._sign, self._int[:prec], self._exp - expdiff))
-
-
- def _round_half_up(self, prec, expdiff, context, tmp = None):
- '''Rounds 5 up (away from 0)'''
- if tmp is None:
- tmp = Decimal((self._sign, self._int[:prec], self._exp - expdiff))
-
- if self._int[prec] >= 5:
- tmp = tmp._increment(round = 0, context = context)
- if len(tmp._int) > prec:
- return Decimal((tmp._sign, tmp._int[:-1], tmp._exp + 1))
-
-
- return tmp
-
-
- def _round_half_even(self, prec, expdiff, context):
- '''Round 5 to even, rest to nearest.'''
- tmp = Decimal((self._sign, self._int[:prec], self._exp - expdiff))
- half = self._int[prec] == 5
- if half:
- for digit in self._int[prec + 1:]:
- if digit != 0:
- half = 0
- break
- continue
-
-
- if half:
- if self._int[prec - 1] & 1 == 0:
- return tmp
-
-
- return self._round_half_up(prec, expdiff, context, tmp)
-
-
- def _round_half_down(self, prec, expdiff, context):
- '''Round 5 down'''
- tmp = Decimal((self._sign, self._int[:prec], self._exp - expdiff))
- half = self._int[prec] == 5
- if half:
- for digit in self._int[prec + 1:]:
- if digit != 0:
- half = 0
- break
- continue
-
-
- if half:
- return tmp
-
- return self._round_half_up(prec, expdiff, context, tmp)
-
-
- def _round_up(self, prec, expdiff, context):
- '''Rounds away from 0.'''
- tmp = Decimal((self._sign, self._int[:prec], self._exp - expdiff))
- for digit in self._int[prec:]:
- if digit != 0:
- tmp = tmp._increment(round = 1, context = context)
- if len(tmp._int) > prec:
- return Decimal((tmp._sign, tmp._int[:-1], tmp._exp + 1))
- else:
- return tmp
- len(tmp._int) > prec
-
- return tmp
-
-
- def _round_ceiling(self, prec, expdiff, context):
- '''Rounds up (not away from 0 if negative.)'''
- if self._sign:
- return self._round_down(prec, expdiff, context)
- else:
- return self._round_up(prec, expdiff, context)
-
-
- def _round_floor(self, prec, expdiff, context):
- '''Rounds down (not towards 0 if negative)'''
- if not self._sign:
- return self._round_down(prec, expdiff, context)
- else:
- return self._round_up(prec, expdiff, context)
-
-
- def __pow__(self, n, modulo = None, context = None):
- """Return self ** n (mod modulo)
-
- If modulo is None (default), don't take it mod modulo.
- """
- n = _convert_other(n)
- if n is NotImplemented:
- return n
-
- if context is None:
- context = getcontext()
-
- if self._is_special and n._is_special or n.adjusted() > 8:
- if n._isinfinity() or n.adjusted() > 8:
- return context._raise_error(InvalidOperation, 'x ** INF')
-
- ans = self._check_nans(n, context)
- if ans:
- return ans
-
-
- if not n._isinteger():
- return context._raise_error(InvalidOperation, 'x ** (non-integer)')
-
- if not self and not n:
- return context._raise_error(InvalidOperation, '0 ** 0')
-
- if not n:
- return Decimal(1)
-
- if self == Decimal(1):
- return Decimal(1)
-
- if self._sign:
- pass
- sign = not n._iseven()
- n = int(n)
- if self._isinfinity():
- if modulo:
- return context._raise_error(InvalidOperation, 'INF % x')
-
- if n > 0:
- return Infsign[sign]
-
- return Decimal((sign, (0,), 0))
-
- if not modulo and n > 0 and (self._exp + len(self._int) - 1) * n > context.Emax and self:
- tmp = Decimal('inf')
- tmp._sign = sign
- context._raise_error(Rounded)
- context._raise_error(Inexact)
- context._raise_error(Overflow, 'Big power', sign)
- return tmp
-
- elength = len(str(abs(n)))
- firstprec = context.prec
- if not modulo and firstprec + elength + 1 > DefaultContext.Emax:
- return context._raise_error(Overflow, 'Too much precision.', sign)
-
- mul = Decimal(self)
- val = Decimal(1)
- context = context._shallow_copy()
- context.prec = firstprec + elength + 1
- if n < 0:
- n = -n
- mul = Decimal(1).__div__(mul, context = context)
-
- spot = 1
- while spot <= n:
- spot <<= 1
- spot >>= 1
- while spot:
- val = val.__mul__(val, context = context)
- if val._isinfinity():
- val = Infsign[sign]
- break
-
- if spot & n:
- val = val.__mul__(mul, context = context)
-
- if modulo is not None:
- val = val.__mod__(modulo, context = context)
-
- spot >>= 1
- context.prec = firstprec
- if context._rounding_decision == ALWAYS_ROUND:
- return val._fix(context)
-
- return val
-
-
- def __rpow__(self, other, context = None):
- '''Swaps self/other and returns __pow__.'''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- return other.__pow__(self, context = context)
-
-
- def normalize(self, context = None):
- '''Normalize- strip trailing 0s, change anything equal to 0 to 0e0'''
- if self._is_special:
- ans = self._check_nans(context = context)
- if ans:
- return ans
-
-
- dup = self._fix(context)
- if dup._isinfinity():
- return dup
-
- if not dup:
- return Decimal((dup._sign, (0,), 0))
-
- end = len(dup._int)
- exp = dup._exp
- while dup._int[end - 1] == 0:
- exp += 1
- end -= 1
- return Decimal((dup._sign, dup._int[:end], exp))
-
-
- def quantize(self, exp, rounding = None, context = None, watchexp = 1):
- '''Quantize self so its exponent is the same as that of exp.
-
- Similar to self._rescale(exp._exp) but with error checking.
- '''
- if self._is_special or exp._is_special:
- ans = self._check_nans(exp, context)
- if ans:
- return ans
-
- if exp._isinfinity() or self._isinfinity():
- if exp._isinfinity() and self._isinfinity():
- return self
-
- if context is None:
- context = getcontext()
-
- return context._raise_error(InvalidOperation, 'quantize with one INF')
-
-
- return self._rescale(exp._exp, rounding, context, watchexp)
-
-
- def same_quantum(self, other):
- '''Test whether self and other have the same exponent.
-
- same as self._exp == other._exp, except NaN == sNaN
- '''
- if self._is_special or other._is_special:
- if self._isnan() or other._isnan():
- if self._isnan() and other._isnan():
- pass
- return True
-
- if self._isinfinity() or other._isinfinity():
- if self._isinfinity() and other._isinfinity():
- pass
- return True
-
-
- return self._exp == other._exp
-
-
- def _rescale(self, exp, rounding = None, context = None, watchexp = 1):
- '''Rescales so that the exponent is exp.
-
- exp = exp to scale to (an integer)
- rounding = rounding version
- watchexp: if set (default) an error is returned if exp is greater
- than Emax or less than Etiny.
- '''
- if context is None:
- context = getcontext()
-
- if self._is_special:
- if self._isinfinity():
- return context._raise_error(InvalidOperation, 'rescale with an INF')
-
- ans = self._check_nans(context = context)
- if ans:
- return ans
-
-
- if watchexp:
- if context.Emax < exp or context.Etiny() > exp:
- return context._raise_error(InvalidOperation, 'rescale(a, INF)')
-
- if not self:
- ans = Decimal(self)
- ans._int = (0,)
- ans._exp = exp
- return ans
-
- diff = self._exp - exp
- digits = len(self._int) + diff
- if watchexp and digits > context.prec:
- return context._raise_error(InvalidOperation, 'Rescale > prec')
-
- tmp = Decimal(self)
- tmp._int = (0,) + tmp._int
- digits += 1
- if digits < 0:
- tmp._exp = -digits + tmp._exp
- tmp._int = (0, 1)
- digits = 1
-
- tmp = tmp._round(digits, rounding, context = context)
- if tmp._int[0] == 0 and len(tmp._int) > 1:
- tmp._int = tmp._int[1:]
-
- tmp._exp = exp
- tmp_adjusted = tmp.adjusted()
- if tmp and tmp_adjusted < context.Emin:
- context._raise_error(Subnormal)
- elif tmp and tmp_adjusted > context.Emax:
- return context._raise_error(InvalidOperation, 'rescale(a, INF)')
-
- return tmp
-
-
- def to_integral(self, rounding = None, context = None):
- '''Rounds to the nearest integer, without raising inexact, rounded.'''
- if self._is_special:
- ans = self._check_nans(context = context)
- if ans:
- return ans
-
-
- if self._exp >= 0:
- return self
-
- if context is None:
- context = getcontext()
-
- flags = context._ignore_flags(Rounded, Inexact)
- ans = self._rescale(0, rounding, context = context)
- context._regard_flags(flags)
- return ans
-
-
- def sqrt(self, context = None):
- '''Return the square root of self.
-
- Uses a converging algorithm (Xn+1 = 0.5*(Xn + self / Xn))
- Should quadratically approach the right answer.
- '''
- if self._is_special:
- ans = self._check_nans(context = context)
- if ans:
- return ans
-
- if self._isinfinity() and self._sign == 0:
- return Decimal(self)
-
-
- if not self:
- exp = self._exp // 2
- if self._sign == 1:
- return Decimal((1, (0,), exp))
- else:
- return Decimal((0, (0,), exp))
-
- if context is None:
- context = getcontext()
-
- if self._sign == 1:
- return context._raise_error(InvalidOperation, 'sqrt(-x), x > 0')
-
- tmp = Decimal(self)
- expadd = tmp._exp // 2
- if tmp._exp & 1:
- tmp._int += (0,)
- tmp._exp = 0
- else:
- tmp._exp = 0
- context = context._shallow_copy()
- flags = context._ignore_all_flags()
- firstprec = context.prec
- context.prec = 3
- Emax = context.Emax
- Emin = context.Emin
- context.Emax = DefaultContext.Emax
- context.Emin = DefaultContext.Emin
- half = Decimal('0.5')
- maxp = firstprec + 2
- rounding = context._set_rounding(ROUND_HALF_EVEN)
- while None:
- context.prec = min(2 * context.prec - 2, maxp)
- ans = half.__mul__(ans.__add__(tmp.__div__(ans, context = context), context = context), context = context)
- if context.prec == maxp:
- break
- continue
- context.prec = firstprec
- prevexp = ans.adjusted()
- ans = ans._round(context = context)
- context.prec = firstprec + 1
- lower = ans.__sub__(Decimal((0, (5,), ans._exp - 1)), context = context)
- context._set_rounding(ROUND_UP)
- if lower.__mul__(lower, context = context) > tmp:
- ans = ans.__sub__(Decimal((0, (1,), ans._exp)), context = context)
- else:
- upper = ans.__add__(Decimal((0, (5,), ans._exp - 1)), context = context)
- context._set_rounding(ROUND_DOWN)
- if upper.__mul__(upper, context = context) < tmp:
- ans = ans.__add__(Decimal((0, (1,), ans._exp)), context = context)
-
- ans._exp += expadd
- context.prec = firstprec
- context.rounding = rounding
- ans = ans._fix(context)
- rounding = context._set_rounding_decision(NEVER_ROUND)
- context.Emax = Emax
- context.Emin = Emin
- return ans._fix(context)
-
-
- def max(self, other, context = None):
- '''Returns the larger value.
-
- like max(self, other) except if one is not a number, returns
- NaN (and signals if one is sNaN). Also rounds.
- '''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- if self._is_special or other._is_special:
- sn = self._isnan()
- on = other._isnan()
- if sn or on:
- if on == 1 and sn != 2:
- return self
-
- if sn == 1 and on != 2:
- return other
-
- return self._check_nans(other, context)
-
-
- ans = self
- c = self.__cmp__(other)
- if c == 0:
- if self._sign != other._sign:
- if self._sign:
- ans = other
-
- elif self._exp < other._exp and not (self._sign):
- ans = other
- elif self._exp > other._exp and self._sign:
- ans = other
-
- elif c == -1:
- ans = other
-
- if context is None:
- context = getcontext()
-
- if context._rounding_decision == ALWAYS_ROUND:
- return ans._fix(context)
-
- return ans
-
-
- def min(self, other, context = None):
- '''Returns the smaller value.
-
- like min(self, other) except if one is not a number, returns
- NaN (and signals if one is sNaN). Also rounds.
- '''
- other = _convert_other(other)
- if other is NotImplemented:
- return other
-
- if self._is_special or other._is_special:
- sn = self._isnan()
- on = other._isnan()
- if sn or on:
- if on == 1 and sn != 2:
- return self
-
- if sn == 1 and on != 2:
- return other
-
- return self._check_nans(other, context)
-
-
- ans = self
- c = self.__cmp__(other)
- if c == 0:
- if self._sign != other._sign:
- if other._sign:
- ans = other
-
- elif self._exp > other._exp and not (self._sign):
- ans = other
- elif self._exp < other._exp and self._sign:
- ans = other
-
- elif c == 1:
- ans = other
-
- if context is None:
- context = getcontext()
-
- if context._rounding_decision == ALWAYS_ROUND:
- return ans._fix(context)
-
- return ans
-
-
- def _isinteger(self):
- '''Returns whether self is an integer'''
- if self._exp >= 0:
- return True
-
- rest = self._int[self._exp:]
- return rest == (0,) * len(rest)
-
-
- def _iseven(self):
- '''Returns 1 if self is even. Assumes self is an integer.'''
- if self._exp > 0:
- return 1
-
- return self._int[-1 + self._exp] & 1 == 0
-
-
- def adjusted(self):
- '''Return the adjusted exponent of self'''
-
- try:
- return self._exp + len(self._int) - 1
- except TypeError:
- return 0
-
-
-
- def __reduce__(self):
- return (self.__class__, (str(self),))
-
-
- def __copy__(self):
- if type(self) == Decimal:
- return self
-
- return self.__class__(str(self))
-
-
- def __deepcopy__(self, memo):
- if type(self) == Decimal:
- return self
-
- return self.__class__(str(self))
-
-
- rounding_functions = [] if name.startswith('_round_') else _[1]
- for name in rounding_functions:
- globalname = name[1:].upper()
- val = globals()[globalname]
- Decimal._pick_rounding_function[val] = name
-
- del name
- del val
- del globalname
- del rounding_functions
-
- class Context(object):
- '''Contains the context for a Decimal instance.
-
- Contains:
- prec - precision (for use in rounding, division, square roots..)
- rounding - rounding type. (how you round)
- _rounding_decision - ALWAYS_ROUND, NEVER_ROUND -- do you round?
- traps - If traps[exception] = 1, then the exception is
- raised when it is caused. Otherwise, a value is
- substituted in.
- flags - When an exception is caused, flags[exception] is incremented.
- (Whether or not the trap_enabler is set)
- Should be reset by user of Decimal instance.
- Emin - Minimum exponent
- Emax - Maximum exponent
- capitals - If 1, 1*10^1 is printed as 1E+1.
- If 0, printed as 1e1
- _clamp - If 1, change exponents if too high (Default 0)
- '''
-
- def __init__(self, prec = None, rounding = None, traps = None, flags = None, _rounding_decision = None, Emin = None, Emax = None, capitals = None, _clamp = 0, _ignored_flags = None):
- if flags is None:
- flags = []
-
- if _ignored_flags is None:
- _ignored_flags = []
-
- for name, val in locals().items():
- if val is None:
- setattr(self, name, _copy.copy(getattr(DefaultContext, name)))
- continue
- None if not isinstance(flags, dict) else dict if traps is not None and not isinstance(traps, dict) else dict
- setattr(self, name, val)
-
- del self.self
-
-
- def __repr__(self):
- '''Show the current context.'''
- s = []
- s.append('Context(prec=%(prec)d, rounding=%(rounding)s, Emin=%(Emin)d, Emax=%(Emax)d, capitals=%(capitals)d' % vars(self))
- ', '.join([] + [](_[1]) + ']')
- ', '.join([] + [](_[1]) + ']')
- return ', '.join(s) + ')'
-
-
- def clear_flags(self):
- '''Reset all flags to zero'''
- for flag in self.flags:
- self.flags[flag] = 0
-
-
-
- def _shallow_copy(self):
- '''Returns a shallow copy from self.'''
- nc = Context(self.prec, self.rounding, self.traps, self.flags, self._rounding_decision, self.Emin, self.Emax, self.capitals, self._clamp, self._ignored_flags)
- return nc
-
-
- def copy(self):
- '''Returns a deep copy from self.'''
- nc = Context(self.prec, self.rounding, self.traps.copy(), self.flags.copy(), self._rounding_decision, self.Emin, self.Emax, self.capitals, self._clamp, self._ignored_flags)
- return nc
-
- __copy__ = copy
-
- def _raise_error(self, condition, explanation = None, *args):
- '''Handles an error
-
- If the flag is in _ignored_flags, returns the default response.
- Otherwise, it increments the flag, then, if the corresponding
- trap_enabler is set, it reaises the exception. Otherwise, it returns
- the default value after incrementing the flag.
- '''
- error = _condition_map.get(condition, condition)
- if error in self._ignored_flags:
- return error().handle(self, *args)
-
- self.flags[error] += 1
- if not self.traps[error]:
- return condition().handle(self, *args)
-
- raise error, explanation
-
-
- def _ignore_all_flags(self):
- '''Ignore all flags, if they are raised'''
- return self._ignore_flags(*_signals)
-
-
- def _ignore_flags(self, *flags):
- '''Ignore the flags, if they are raised'''
- self._ignored_flags = self._ignored_flags + list(flags)
- return list(flags)
-
-
- def _regard_flags(self, *flags):
- '''Stop ignoring the flags, if they are raised'''
- if flags and isinstance(flags[0], (tuple, list)):
- flags = flags[0]
-
- for flag in flags:
- self._ignored_flags.remove(flag)
-
-
-
- def __hash__(self):
- '''A Context cannot be hashed.'''
- raise TypeError, 'Cannot hash a Context.'
-
-
- def Etiny(self):
- '''Returns Etiny (= Emin - prec + 1)'''
- return int((self.Emin - self.prec) + 1)
-
-
- def Etop(self):
- '''Returns maximum exponent (= Emax - prec + 1)'''
- return int((self.Emax - self.prec) + 1)
-
-
- def _set_rounding_decision(self, type):
- """Sets the rounding decision.
-
- Sets the rounding decision, and returns the current (previous)
- rounding decision. Often used like:
-
- context = context._shallow_copy()
- # That so you don't change the calling context
- # if an error occurs in the middle (say DivisionImpossible is raised).
-
- rounding = context._set_rounding_decision(NEVER_ROUND)
- instance = instance / Decimal(2)
- context._set_rounding_decision(rounding)
-
- This will make it not round for that operation.
- """
- rounding = self._rounding_decision
- self._rounding_decision = type
- return rounding
-
-
- def _set_rounding(self, type):
- """Sets the rounding type.
-
- Sets the rounding type, and returns the current (previous)
- rounding type. Often used like:
-
- context = context.copy()
- # so you don't change the calling context
- # if an error occurs in the middle.
- rounding = context._set_rounding(ROUND_UP)
- val = self.__sub__(other, context=context)
- context._set_rounding(rounding)
-
- This will make it round up for that operation.
- """
- rounding = self.rounding
- self.rounding = type
- return rounding
-
-
- def create_decimal(self, num = '0'):
- '''Creates a new Decimal instance but using self as context.'''
- d = Decimal(num, context = self)
- return d._fix(self)
-
-
- def abs(self, a):
- '''Returns the absolute value of the operand.
-
- If the operand is negative, the result is the same as using the minus
- operation on the operand. Otherwise, the result is the same as using
- the plus operation on the operand.
-
- >>> ExtendedContext.abs(Decimal(\'2.1\'))
- Decimal("2.1")
- >>> ExtendedContext.abs(Decimal(\'-100\'))
- Decimal("100")
- >>> ExtendedContext.abs(Decimal(\'101.5\'))
- Decimal("101.5")
- >>> ExtendedContext.abs(Decimal(\'-101.5\'))
- Decimal("101.5")
- '''
- return a.__abs__(context = self)
-
-
- def add(self, a, b):
- '''Return the sum of the two operands.
-
- >>> ExtendedContext.add(Decimal(\'12\'), Decimal(\'7.00\'))
- Decimal("19.00")
- >>> ExtendedContext.add(Decimal(\'1E+2\'), Decimal(\'1.01E+4\'))
- Decimal("1.02E+4")
- '''
- return a.__add__(b, context = self)
-
-
- def _apply(self, a):
- return str(a._fix(self))
-
-
- def compare(self, a, b):
- '''Compares values numerically.
-
- If the signs of the operands differ, a value representing each operand
- (\'-1\' if the operand is less than zero, \'0\' if the operand is zero or
- negative zero, or \'1\' if the operand is greater than zero) is used in
- place of that operand for the comparison instead of the actual
- operand.
-
- The comparison is then effected by subtracting the second operand from
- the first and then returning a value according to the result of the
- subtraction: \'-1\' if the result is less than zero, \'0\' if the result is
- zero or negative zero, or \'1\' if the result is greater than zero.
-
- >>> ExtendedContext.compare(Decimal(\'2.1\'), Decimal(\'3\'))
- Decimal("-1")
- >>> ExtendedContext.compare(Decimal(\'2.1\'), Decimal(\'2.1\'))
- Decimal("0")
- >>> ExtendedContext.compare(Decimal(\'2.1\'), Decimal(\'2.10\'))
- Decimal("0")
- >>> ExtendedContext.compare(Decimal(\'3\'), Decimal(\'2.1\'))
- Decimal("1")
- >>> ExtendedContext.compare(Decimal(\'2.1\'), Decimal(\'-3\'))
- Decimal("1")
- >>> ExtendedContext.compare(Decimal(\'-3\'), Decimal(\'2.1\'))
- Decimal("-1")
- '''
- return a.compare(b, context = self)
-
-
- def divide(self, a, b):
- '''Decimal division in a specified context.
-
- >>> ExtendedContext.divide(Decimal(\'1\'), Decimal(\'3\'))
- Decimal("0.333333333")
- >>> ExtendedContext.divide(Decimal(\'2\'), Decimal(\'3\'))
- Decimal("0.666666667")
- >>> ExtendedContext.divide(Decimal(\'5\'), Decimal(\'2\'))
- Decimal("2.5")
- >>> ExtendedContext.divide(Decimal(\'1\'), Decimal(\'10\'))
- Decimal("0.1")
- >>> ExtendedContext.divide(Decimal(\'12\'), Decimal(\'12\'))
- Decimal("1")
- >>> ExtendedContext.divide(Decimal(\'8.00\'), Decimal(\'2\'))
- Decimal("4.00")
- >>> ExtendedContext.divide(Decimal(\'2.400\'), Decimal(\'2.0\'))
- Decimal("1.20")
- >>> ExtendedContext.divide(Decimal(\'1000\'), Decimal(\'100\'))
- Decimal("10")
- >>> ExtendedContext.divide(Decimal(\'1000\'), Decimal(\'1\'))
- Decimal("1000")
- >>> ExtendedContext.divide(Decimal(\'2.40E+6\'), Decimal(\'2\'))
- Decimal("1.20E+6")
- '''
- return a.__div__(b, context = self)
-
-
- def divide_int(self, a, b):
- '''Divides two numbers and returns the integer part of the result.
-
- >>> ExtendedContext.divide_int(Decimal(\'2\'), Decimal(\'3\'))
- Decimal("0")
- >>> ExtendedContext.divide_int(Decimal(\'10\'), Decimal(\'3\'))
- Decimal("3")
- >>> ExtendedContext.divide_int(Decimal(\'1\'), Decimal(\'0.3\'))
- Decimal("3")
- '''
- return a.__floordiv__(b, context = self)
-
-
- def divmod(self, a, b):
- return a.__divmod__(b, context = self)
-
-
- def max(self, a, b):
- '''max compares two values numerically and returns the maximum.
-
- If either operand is a NaN then the general rules apply.
- Otherwise, the operands are compared as as though by the compare
- operation. If they are numerically equal then the left-hand operand
- is chosen as the result. Otherwise the maximum (closer to positive
- infinity) of the two operands is chosen as the result.
-
- >>> ExtendedContext.max(Decimal(\'3\'), Decimal(\'2\'))
- Decimal("3")
- >>> ExtendedContext.max(Decimal(\'-10\'), Decimal(\'3\'))
- Decimal("3")
- >>> ExtendedContext.max(Decimal(\'1.0\'), Decimal(\'1\'))
- Decimal("1")
- >>> ExtendedContext.max(Decimal(\'7\'), Decimal(\'NaN\'))
- Decimal("7")
- '''
- return a.max(b, context = self)
-
-
- def min(self, a, b):
- '''min compares two values numerically and returns the minimum.
-
- If either operand is a NaN then the general rules apply.
- Otherwise, the operands are compared as as though by the compare
- operation. If they are numerically equal then the left-hand operand
- is chosen as the result. Otherwise the minimum (closer to negative
- infinity) of the two operands is chosen as the result.
-
- >>> ExtendedContext.min(Decimal(\'3\'), Decimal(\'2\'))
- Decimal("2")
- >>> ExtendedContext.min(Decimal(\'-10\'), Decimal(\'3\'))
- Decimal("-10")
- >>> ExtendedContext.min(Decimal(\'1.0\'), Decimal(\'1\'))
- Decimal("1.0")
- >>> ExtendedContext.min(Decimal(\'7\'), Decimal(\'NaN\'))
- Decimal("7")
- '''
- return a.min(b, context = self)
-
-
- def minus(self, a):
- '''Minus corresponds to unary prefix minus in Python.
-
- The operation is evaluated using the same rules as subtract; the
- operation minus(a) is calculated as subtract(\'0\', a) where the \'0\'
- has the same exponent as the operand.
-
- >>> ExtendedContext.minus(Decimal(\'1.3\'))
- Decimal("-1.3")
- >>> ExtendedContext.minus(Decimal(\'-1.3\'))
- Decimal("1.3")
- '''
- return a.__neg__(context = self)
-
-
- def multiply(self, a, b):
- '''multiply multiplies two operands.
-
- If either operand is a special value then the general rules apply.
- Otherwise, the operands are multiplied together (\'long multiplication\'),
- resulting in a number which may be as long as the sum of the lengths
- of the two operands.
-
- >>> ExtendedContext.multiply(Decimal(\'1.20\'), Decimal(\'3\'))
- Decimal("3.60")
- >>> ExtendedContext.multiply(Decimal(\'7\'), Decimal(\'3\'))
- Decimal("21")
- >>> ExtendedContext.multiply(Decimal(\'0.9\'), Decimal(\'0.8\'))
- Decimal("0.72")
- >>> ExtendedContext.multiply(Decimal(\'0.9\'), Decimal(\'-0\'))
- Decimal("-0.0")
- >>> ExtendedContext.multiply(Decimal(\'654321\'), Decimal(\'654321\'))
- Decimal("4.28135971E+11")
- '''
- return a.__mul__(b, context = self)
-
-
- def normalize(self, a):
- '''normalize reduces an operand to its simplest form.
-
- Essentially a plus operation with all trailing zeros removed from the
- result.
-
- >>> ExtendedContext.normalize(Decimal(\'2.1\'))
- Decimal("2.1")
- >>> ExtendedContext.normalize(Decimal(\'-2.0\'))
- Decimal("-2")
- >>> ExtendedContext.normalize(Decimal(\'1.200\'))
- Decimal("1.2")
- >>> ExtendedContext.normalize(Decimal(\'-120\'))
- Decimal("-1.2E+2")
- >>> ExtendedContext.normalize(Decimal(\'120.00\'))
- Decimal("1.2E+2")
- >>> ExtendedContext.normalize(Decimal(\'0.00\'))
- Decimal("0")
- '''
- return a.normalize(context = self)
-
-
- def plus(self, a):
- '''Plus corresponds to unary prefix plus in Python.
-
- The operation is evaluated using the same rules as add; the
- operation plus(a) is calculated as add(\'0\', a) where the \'0\'
- has the same exponent as the operand.
-
- >>> ExtendedContext.plus(Decimal(\'1.3\'))
- Decimal("1.3")
- >>> ExtendedContext.plus(Decimal(\'-1.3\'))
- Decimal("-1.3")
- '''
- return a.__pos__(context = self)
-
-
- def power(self, a, b, modulo = None):
- '''Raises a to the power of b, to modulo if given.
-
- The right-hand operand must be a whole number whose integer part (after
- any exponent has been applied) has no more than 9 digits and whose
- fractional part (if any) is all zeros before any rounding. The operand
- may be positive, negative, or zero; if negative, the absolute value of
- the power is used, and the left-hand operand is inverted (divided into
- 1) before use.
-
- If the increased precision needed for the intermediate calculations
- exceeds the capabilities of the implementation then an Invalid operation
- condition is raised.
-
- If, when raising to a negative power, an underflow occurs during the
- division into 1, the operation is not halted at that point but
- continues.
-
- >>> ExtendedContext.power(Decimal(\'2\'), Decimal(\'3\'))
- Decimal("8")
- >>> ExtendedContext.power(Decimal(\'2\'), Decimal(\'-3\'))
- Decimal("0.125")
- >>> ExtendedContext.power(Decimal(\'1.7\'), Decimal(\'8\'))
- Decimal("69.7575744")
- >>> ExtendedContext.power(Decimal(\'Infinity\'), Decimal(\'-2\'))
- Decimal("0")
- >>> ExtendedContext.power(Decimal(\'Infinity\'), Decimal(\'-1\'))
- Decimal("0")
- >>> ExtendedContext.power(Decimal(\'Infinity\'), Decimal(\'0\'))
- Decimal("1")
- >>> ExtendedContext.power(Decimal(\'Infinity\'), Decimal(\'1\'))
- Decimal("Infinity")
- >>> ExtendedContext.power(Decimal(\'Infinity\'), Decimal(\'2\'))
- Decimal("Infinity")
- >>> ExtendedContext.power(Decimal(\'-Infinity\'), Decimal(\'-2\'))
- Decimal("0")
- >>> ExtendedContext.power(Decimal(\'-Infinity\'), Decimal(\'-1\'))
- Decimal("-0")
- >>> ExtendedContext.power(Decimal(\'-Infinity\'), Decimal(\'0\'))
- Decimal("1")
- >>> ExtendedContext.power(Decimal(\'-Infinity\'), Decimal(\'1\'))
- Decimal("-Infinity")
- >>> ExtendedContext.power(Decimal(\'-Infinity\'), Decimal(\'2\'))
- Decimal("Infinity")
- >>> ExtendedContext.power(Decimal(\'0\'), Decimal(\'0\'))
- Decimal("NaN")
- '''
- return a.__pow__(b, modulo, context = self)
-
-
- def quantize(self, a, b):
- '''Returns a value equal to \'a\' (rounded) and having the exponent of \'b\'.
-
- The coefficient of the result is derived from that of the left-hand
- operand. It may be rounded using the current rounding setting (if the
- exponent is being increased), multiplied by a positive power of ten (if
- the exponent is being decreased), or is unchanged (if the exponent is
- already equal to that of the right-hand operand).
-
- Unlike other operations, if the length of the coefficient after the
- quantize operation would be greater than precision then an Invalid
- operation condition is raised. This guarantees that, unless there is an
- error condition, the exponent of the result of a quantize is always
- equal to that of the right-hand operand.
-
- Also unlike other operations, quantize will never raise Underflow, even
- if the result is subnormal and inexact.
-
- >>> ExtendedContext.quantize(Decimal(\'2.17\'), Decimal(\'0.001\'))
- Decimal("2.170")
- >>> ExtendedContext.quantize(Decimal(\'2.17\'), Decimal(\'0.01\'))
- Decimal("2.17")
- >>> ExtendedContext.quantize(Decimal(\'2.17\'), Decimal(\'0.1\'))
- Decimal("2.2")
- >>> ExtendedContext.quantize(Decimal(\'2.17\'), Decimal(\'1e+0\'))
- Decimal("2")
- >>> ExtendedContext.quantize(Decimal(\'2.17\'), Decimal(\'1e+1\'))
- Decimal("0E+1")
- >>> ExtendedContext.quantize(Decimal(\'-Inf\'), Decimal(\'Infinity\'))
- Decimal("-Infinity")
- >>> ExtendedContext.quantize(Decimal(\'2\'), Decimal(\'Infinity\'))
- Decimal("NaN")
- >>> ExtendedContext.quantize(Decimal(\'-0.1\'), Decimal(\'1\'))
- Decimal("-0")
- >>> ExtendedContext.quantize(Decimal(\'-0\'), Decimal(\'1e+5\'))
- Decimal("-0E+5")
- >>> ExtendedContext.quantize(Decimal(\'+35236450.6\'), Decimal(\'1e-2\'))
- Decimal("NaN")
- >>> ExtendedContext.quantize(Decimal(\'-35236450.6\'), Decimal(\'1e-2\'))
- Decimal("NaN")
- >>> ExtendedContext.quantize(Decimal(\'217\'), Decimal(\'1e-1\'))
- Decimal("217.0")
- >>> ExtendedContext.quantize(Decimal(\'217\'), Decimal(\'1e-0\'))
- Decimal("217")
- >>> ExtendedContext.quantize(Decimal(\'217\'), Decimal(\'1e+1\'))
- Decimal("2.2E+2")
- >>> ExtendedContext.quantize(Decimal(\'217\'), Decimal(\'1e+2\'))
- Decimal("2E+2")
- '''
- return a.quantize(b, context = self)
-
-
- def remainder(self, a, b):
- '''Returns the remainder from integer division.
-
- The result is the residue of the dividend after the operation of
- calculating integer division as described for divide-integer, rounded to
- precision digits if necessary. The sign of the result, if non-zero, is
- the same as that of the original dividend.
-
- This operation will fail under the same conditions as integer division
- (that is, if integer division on the same two operands would fail, the
- remainder cannot be calculated).
-
- >>> ExtendedContext.remainder(Decimal(\'2.1\'), Decimal(\'3\'))
- Decimal("2.1")
- >>> ExtendedContext.remainder(Decimal(\'10\'), Decimal(\'3\'))
- Decimal("1")
- >>> ExtendedContext.remainder(Decimal(\'-10\'), Decimal(\'3\'))
- Decimal("-1")
- >>> ExtendedContext.remainder(Decimal(\'10.2\'), Decimal(\'1\'))
- Decimal("0.2")
- >>> ExtendedContext.remainder(Decimal(\'10\'), Decimal(\'0.3\'))
- Decimal("0.1")
- >>> ExtendedContext.remainder(Decimal(\'3.6\'), Decimal(\'1.3\'))
- Decimal("1.0")
- '''
- return a.__mod__(b, context = self)
-
-
- def remainder_near(self, a, b):
- '''Returns to be "a - b * n", where n is the integer nearest the exact
- value of "x / b" (if two integers are equally near then the even one
- is chosen). If the result is equal to 0 then its sign will be the
- sign of a.
-
- This operation will fail under the same conditions as integer division
- (that is, if integer division on the same two operands would fail, the
- remainder cannot be calculated).
-
- >>> ExtendedContext.remainder_near(Decimal(\'2.1\'), Decimal(\'3\'))
- Decimal("-0.9")
- >>> ExtendedContext.remainder_near(Decimal(\'10\'), Decimal(\'6\'))
- Decimal("-2")
- >>> ExtendedContext.remainder_near(Decimal(\'10\'), Decimal(\'3\'))
- Decimal("1")
- >>> ExtendedContext.remainder_near(Decimal(\'-10\'), Decimal(\'3\'))
- Decimal("-1")
- >>> ExtendedContext.remainder_near(Decimal(\'10.2\'), Decimal(\'1\'))
- Decimal("0.2")
- >>> ExtendedContext.remainder_near(Decimal(\'10\'), Decimal(\'0.3\'))
- Decimal("0.1")
- >>> ExtendedContext.remainder_near(Decimal(\'3.6\'), Decimal(\'1.3\'))
- Decimal("-0.3")
- '''
- return a.remainder_near(b, context = self)
-
-
- def same_quantum(self, a, b):
- """Returns True if the two operands have the same exponent.
-
- The result is never affected by either the sign or the coefficient of
- either operand.
-
- >>> ExtendedContext.same_quantum(Decimal('2.17'), Decimal('0.001'))
- False
- >>> ExtendedContext.same_quantum(Decimal('2.17'), Decimal('0.01'))
- True
- >>> ExtendedContext.same_quantum(Decimal('2.17'), Decimal('1'))
- False
- >>> ExtendedContext.same_quantum(Decimal('Inf'), Decimal('-Inf'))
- True
- """
- return a.same_quantum(b)
-
-
- def sqrt(self, a):
- '''Returns the square root of a non-negative number to context precision.
-
- If the result must be inexact, it is rounded using the round-half-even
- algorithm.
-
- >>> ExtendedContext.sqrt(Decimal(\'0\'))
- Decimal("0")
- >>> ExtendedContext.sqrt(Decimal(\'-0\'))
- Decimal("-0")
- >>> ExtendedContext.sqrt(Decimal(\'0.39\'))
- Decimal("0.624499800")
- >>> ExtendedContext.sqrt(Decimal(\'100\'))
- Decimal("10")
- >>> ExtendedContext.sqrt(Decimal(\'1\'))
- Decimal("1")
- >>> ExtendedContext.sqrt(Decimal(\'1.0\'))
- Decimal("1.0")
- >>> ExtendedContext.sqrt(Decimal(\'1.00\'))
- Decimal("1.0")
- >>> ExtendedContext.sqrt(Decimal(\'7\'))
- Decimal("2.64575131")
- >>> ExtendedContext.sqrt(Decimal(\'10\'))
- Decimal("3.16227766")
- >>> ExtendedContext.prec
- 9
- '''
- return a.sqrt(context = self)
-
-
- def subtract(self, a, b):
- '''Return the difference between the two operands.
-
- >>> ExtendedContext.subtract(Decimal(\'1.3\'), Decimal(\'1.07\'))
- Decimal("0.23")
- >>> ExtendedContext.subtract(Decimal(\'1.3\'), Decimal(\'1.30\'))
- Decimal("0.00")
- >>> ExtendedContext.subtract(Decimal(\'1.3\'), Decimal(\'2.07\'))
- Decimal("-0.77")
- '''
- return a.__sub__(b, context = self)
-
-
- def to_eng_string(self, a):
- '''Converts a number to a string, using scientific notation.
-
- The operation is not affected by the context.
- '''
- return a.to_eng_string(context = self)
-
-
- def to_sci_string(self, a):
- '''Converts a number to a string, using scientific notation.
-
- The operation is not affected by the context.
- '''
- return a.__str__(context = self)
-
-
- def to_integral(self, a):
- '''Rounds to an integer.
-
- When the operand has a negative exponent, the result is the same
- as using the quantize() operation using the given operand as the
- left-hand-operand, 1E+0 as the right-hand-operand, and the precision
- of the operand as the precision setting, except that no flags will
- be set. The rounding mode is taken from the context.
-
- >>> ExtendedContext.to_integral(Decimal(\'2.1\'))
- Decimal("2")
- >>> ExtendedContext.to_integral(Decimal(\'100\'))
- Decimal("100")
- >>> ExtendedContext.to_integral(Decimal(\'100.0\'))
- Decimal("100")
- >>> ExtendedContext.to_integral(Decimal(\'101.5\'))
- Decimal("102")
- >>> ExtendedContext.to_integral(Decimal(\'-101.5\'))
- Decimal("-102")
- >>> ExtendedContext.to_integral(Decimal(\'10E+5\'))
- Decimal("1.0E+6")
- >>> ExtendedContext.to_integral(Decimal(\'7.89E+77\'))
- Decimal("7.89E+77")
- >>> ExtendedContext.to_integral(Decimal(\'-Inf\'))
- Decimal("-Infinity")
- '''
- return a.to_integral(context = self)
-
-
-
- class _WorkRep(object):
- __slots__ = ('sign', 'int', 'exp')
-
- def __init__(self, value = None):
- if value is None:
- self.sign = None
- self.int = 0
- self.exp = None
- elif isinstance(value, Decimal):
- self.sign = value._sign
- cum = 0
- for digit in value._int:
- cum = cum * 10 + digit
-
- self.int = cum
- self.exp = value._exp
- else:
- self.sign = value[0]
- self.int = value[1]
- self.exp = value[2]
-
-
- def __repr__(self):
- return '(%r, %r, %r)' % (self.sign, self.int, self.exp)
-
- __str__ = __repr__
-
-
- def _normalize(op1, op2, shouldround = 0, prec = 0):
- '''Normalizes op1, op2 to have the same exp and length of coefficient.
-
- Done during addition.
- '''
- numdigits = int(op1.exp - op2.exp)
- if numdigits < 0:
- numdigits = -numdigits
- tmp = op2
- other = op1
- else:
- tmp = op1
- other = op2
- if shouldround and numdigits > prec + 1:
- tmp_len = len(str(tmp.int))
- other_len = len(str(other.int))
- if numdigits > other_len + prec + 1 - tmp_len:
- extend = prec + 2 - tmp_len
- if extend <= 0:
- extend = 1
-
- tmp.int *= 10 ** extend
- tmp.exp -= extend
- other.int = 1
- other.exp = tmp.exp
- return (op1, op2)
-
-
- tmp.int *= 10 ** numdigits
- tmp.exp -= numdigits
- return (op1, op2)
-
-
- def _adjust_coefficients(op1, op2):
- '''Adjust op1, op2 so that op2.int * 10 > op1.int >= op2.int.
-
- Returns the adjusted op1, op2 as well as the change in op1.exp-op2.exp.
-
- Used on _WorkRep instances during division.
- '''
- adjust = 0
- while op2.int > op1.int:
- op1.int *= 10
- op1.exp -= 1
- adjust += 1
- continue
- op1
- while op1.int >= 10 * op2.int:
- op2.int *= 10
- op2.exp -= 1
- adjust -= 1
- continue
- op2
- return (op1, op2, adjust)
-
-
- def _convert_other(other):
- """Convert other to Decimal.
-
- Verifies that it's ok to use in an implicit construction.
- """
- if isinstance(other, Decimal):
- return other
-
- if isinstance(other, (int, long)):
- return Decimal(other)
-
- return NotImplemented
-
- _infinity_map = {
- 'inf': 1,
- 'infinity': 1,
- '+inf': 1,
- '+infinity': 1,
- '-inf': -1,
- '-infinity': -1 }
-
- def _isinfinity(num):
- '''Determines whether a string or float is infinity.
-
- +1 for negative infinity; 0 for finite ; +1 for positive infinity
- '''
- num = str(num).lower()
- return _infinity_map.get(num, 0)
-
-
- def _isnan(num):
- '''Determines whether a string or float is NaN
-
- (1, sign, diagnostic info as string) => NaN
- (2, sign, diagnostic info as string) => sNaN
- 0 => not a NaN
- '''
- num = str(num).lower()
- if not num:
- return 0
-
- sign = 0
- if num[0] == '+':
- num = num[1:]
- elif num[0] == '-':
- num = num[1:]
- sign = 1
-
- if num.startswith('nan'):
- if len(num) > 3 and not num[3:].isdigit():
- return 0
-
- return (1, sign, num[3:].lstrip('0'))
-
- if num.startswith('snan'):
- if len(num) > 4 and not num[4:].isdigit():
- return 0
-
- return (2, sign, num[4:].lstrip('0'))
-
- return 0
-
- DefaultContext = Context(prec = 28, rounding = ROUND_HALF_EVEN, traps = [
- DivisionByZero,
- Overflow,
- InvalidOperation], flags = [], _rounding_decision = ALWAYS_ROUND, Emax = 999999999, Emin = -999999999, capitals = 1)
- BasicContext = Context(prec = 9, rounding = ROUND_HALF_UP, traps = [
- DivisionByZero,
- Overflow,
- InvalidOperation,
- Clamped,
- Underflow], flags = [])
- ExtendedContext = Context(prec = 9, rounding = ROUND_HALF_EVEN, traps = [], flags = [])
- Inf = Decimal('Inf')
- negInf = Decimal('-Inf')
- Infsign = (Inf, negInf)
- NaN = Decimal('NaN')
- import re
- _parser = re.compile('\n# \\s*\n (?P<sign>[-+])?\n (\n (?P<int>\\d+) (\\. (?P<frac>\\d*))?\n |\n \\. (?P<onlyfrac>\\d+)\n )\n ([eE](?P<exp>[-+]? \\d+))?\n# \\s*\n $\n', re.VERBOSE).match
- del re
-
- def _string2exact(s):
- m = _parser(s)
- if m is None:
- raise ValueError('invalid literal for Decimal: %r' % s)
-
- if m.group('sign') == '-':
- sign = 1
- else:
- sign = 0
- exp = m.group('exp')
- if exp is None:
- exp = 0
- else:
- exp = int(exp)
- intpart = m.group('int')
- if intpart is None:
- intpart = ''
- fracpart = m.group('onlyfrac')
- else:
- fracpart = m.group('frac')
- if fracpart is None:
- fracpart = ''
-
- exp -= len(fracpart)
- mantissa = intpart + fracpart
- tmp = map(int, mantissa)
- backup = tmp
- while tmp and tmp[0] == 0:
- del tmp[0]
- if not tmp:
- if backup:
- return (sign, tuple(backup), exp)
-
- return (sign, (0,), exp)
-
- mantissa = tuple(tmp)
- return (sign, mantissa, exp)
-
- if __name__ == '__main__':
- import doctest
- import sys
- doctest.testmod(sys.modules[__name__])
-
-